// 封装一个防抖函数
// 防抖函数的作用：在一定时间内，只执行最后一次操作
// 例如：用户在输入框输入内容，只有在输入完成后，才会触发请求
// 例如：用户在点击按钮，只有在点击完成后，才会触发请求
// function debounce(fn, delay) {
//   let timer = null;
//   return function () {
//     if (timer) {
//       clearTimeout(timer);
//     }
//     timer = setTimeout(fn, delay);
//   };
// }

// 封装一个节流函数
// 节流函数的作用：在一定时间内，只执行一次操作
// function throttle(fn, delay) {
//   let flag = true;
//   return function () {
//     if (!flag) return;
//     flag = false;
//     setTimeout(() => {
//       fn();
//       flag = true;
//     }, delay);
//   };
// }

// 请写出以下输出结果：
// function Foo() {
//   getName = function () {
//     alert(1);
//   };
//   return this;
// }
// Foo.getName = function () {
//   alert(2);
// };
// Foo.prototype.getName = function () {
//   alert(3);
// };
// var getName = function () {
//   alert(4);
// };
// function getName() {
//   alert(5);
// }

// // 请写出以下输出结果：
// Foo.getName();
// getName();
// Foo().getName();
// getName();

// 17. 使用ES6的class实现Person类，自由设定二个属性和一个方法，然后Student类继承Person类下面所有的属性和方法。
// class Person {
//   constructor(props) {
//     // console.log("我是父类");
//     this.name = props.name;
//     this.age = props.age;
//   }
//   name = "张三";
//   age = 18;
//   sayName() {
//     return this.name;
//   }
// }

// class Student extends Person {
//   constructor(props) {
//     super(props);
//     // console.log(props);
//   }
// }

// 当我们去生成实例的时候，会自动调用constructor方法
// 传进去的参数会作为constructor方法的参数
// const student = new Student({ name: "李四", age: 20 });
// console.log(student.name);
// console.log(student.age);

// const http = require("http");
// console.log(http);

// const arr = [2, 1, 3, 5, 4, 2, 5];
// const sort = (arr) => {
//   const newArr = [
//     ...new Set(
//       arr.sort((a, b) => {
//         return a - b;
//       })
//     ),
//   ];
//   return {
//     arr: newArr,
//     max: newArr[newArr.length - 1],
//     min: newArr[0],
//   };
// };
// console.log(sort(arr));

// const sleep = (time) => {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       resolve();
//     }, time);
//   });
// };

// sleep(2000).then(() => {
//   console.log(123);
// });

// 深浅拷贝
// const obj = {
//   a: 3,
//   b: 4,
// };
// const obj2 = {...obj};
// const obj2 = Object.assign({}, obj);

// const arr = [1, 2, 3];
// const arr2 = [...arr];
// const arr2 = [].concat(arr);

const obj = {
  a: 3,
  b: 4,
  c: {
    x: 10,
  },
  d: function () {},
  e: undefined,
};
// const obj2 = { ...obj };
// obj2.c.x = 30;
// console.log(obj);
// const obj2 = JSON.parse(JSON.stringify(obj));
// console.log(obj2);

// 用递归的方式写一个深拷贝
function deepClone(obj) {
  // 如果obj不是对象或者是null，那么直接返回obj
  if (typeof obj !== "object" || obj === null) {
    return obj;
  }
  let result;
  if (obj instanceof Array) {
    result = [];
  } else {
    result = {};
  }
  for (let key in obj) {
    // 下面这句话什么意思？
    // 如果obj[key]是对象，那么就递归调用deepClone函数
    if (obj.hasOwnProperty(key)) {
      result[key] = deepClone(obj[key]);
    }
  }
  return result;
}
const obj2 = deepClone(obj);
console.log(obj2);
